public class Main {
    public static void main(String[] args) {
//        for(int i=1000;i<=2000;i++) {
//            if(i%4==0 && i%100!=0 || i%400==0)
//                System.out.print(i+" ");
//        }


//        double x=2.0;
//        int y=4;
//        x/=++y;
//        System.out.println(x);

//        int a = 10;
//        System.out.println(!a);

//        byte a = 10;
//        short b = 20;
//        int c = 30;
//        long d = 40L;
//        float e = 1.0f;
//        double f = 3.14;
//        char g = '中';
//        boolean h = true;
//        long a = 10L;   //为了区分 int 和 long 类型，一般建议：long 类型变量后面加上 'l' 或者 'L'
//        long b = 20l;   //一般更加以大写 L ,因为小写 l 容易与数字 1 相混淆
//
//        float c = 3.14f;   //为了区分 float 和 double 类型，一般建议：float 类型变量后面加上 'f' 或者 'F'
//        float d = 3.14F;   //

//        char a = 65;
//        char b = '中';
//        System.out.println(a);  //输出 A
//        System.out.println(b);  //输出 中

//        int a;
//        long b;
//        char c;
//        double d;
//        System.out.println(a);
//        a=10;
//        System.out.println(a);
////        System.out.println(c);
////        System.out.println(d);


//        int a = 10;
//        System.out.println(a);  //这样没问题
//
//        int b;
//        b = 20;
//        System.out.println(b);  //这样也没问题
//
//        int c;
////        System.out.println(c);  //执行了这一步就会报错，因为 c 没有初始化，所以不能使用

//        boolean a = true;
//        boolean b = false;
//        System.out.println(a);  //输出 true
//        System.out.println(b);  //输出 false



//        int a = 10;
//        int b = 20;
//        int c = a / b;
//        System.out.println(c);  //输出 0，注意：java 里整数除法的结果是整数，所以 10/20 等于 0
//
////        doule d = a / b;
////        System.out.println(d);  //
//        System.out.println(10.0/20);  //
//
//        double e = (double) a / b;
//        System.out.println(e);  //输出 0.5，注意：强制类型转换可以得到正确的结果


//        System.out.println(1024);   //整形默认是 int 类型，所以输出 1024
//        System.out.println(3.14);   //浮点型默认是 double 类型，所以输出 3.14
//
//        int a = 100;
//        long b = 10L;
//        b = a;  //a和b都是整形，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a提升为long类型，然后赋值
////        a = b;  //编译报错，long的范围比int的范围大，会有数据丢失，不安全
//
//        float f = 3.14f;
//        double d = 5.12;
//
//        d = f;  //编译器会将f转换为double，然后进行赋值
////        f = d;  //编译报错，long的范围比int的范围大，会有数据丢失，不安全
//
//        byte b1 = 100;  //编译通过，100没有超出byte的范围，编译器隐式将100转换为byte类型
////        byte b2 = 128;  //编译报错，128超出byte的范围，超出了byte的范围，有数据丢失

//        int a = 10;
//        long b = 20L;
//        b = a;  //int-->long,数据类型由小到大，隐式转换
//        a = (int) b;  //long-->int,数据类型由大到小，需要强转，否则编译失败
//
//        float f = 3.14f;
//        double d = 5.12;
//        d = f;  //float-->double,数据类型由小到大，隐式转换
//        f = (float) d;  //double-->float,数据类型由大到小，需要强转，否则编译失败
//
////        a = d;  //编译报错，类型不兼容
//        a = (int) d;  //int类型没有double表示的数据范围大，需要强转，小数点之后的全部丢弃
//
//        byte b1 = 100;  //编译通过，100默认为int类型，没有超出byte的范围，编译器隐式将100转换为byte类型
//        byte b2 = (byte) 257;  //257默认为int，超出byte的范围，需要显式转换，否则编译失败
//
//        boolean flag = true;
////        a = flag;  //编译失败：类型不兼容
////        flag = a;  //编译失败：类型不兼容


//        int a = 10;
//        long b = 20L;
////        int c = a + b;  //编译报错,a + b ==> int + long -> long + long .赋值给int时会丢失数据
//        long d = a + b;  //编译通过，a + b ==> int + long -> long + long .赋值给long时不会丢失数据

        byte a = 10;
        byte b = 20;
//        byte c = a + b;   //编译报错，byte + byte -> int + int .但把int类型赋值给byte时会丢失数据。
        byte c = (byte) (a + b);  //编译通过

    }
}